COMMENT ⊗   VALID 00006 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002		EECS 129
C00004 00003		Part one: Functions as passive objects
C00010 00004		Part two: Functions as active objects
C00012 00005			  EECS 129: The Art of Computer Science
C00017 00006
C00023 ENDMK
C⊗;
	EECS 129

books:  zen and the art of motorcycle maintenance
	mindstorms
	godel, escher, bach
	lisp notes
	decline of the west

languages: mince, 
	   logo, 
	   lisp, 
	   c, 
	   visicalc, 
	   mu-math, 
	   zork, 
	   db lang.

week 1: start the "where" (we're going)
M overview; read  zen
T read mindstorms ch 1-2
TH discuss 1-2
F read ms 3

lab mince/emacs


week 2: start the "what" (is computation)
M  read ms 3
   start the computational ideas  
	use geb, and formal theory  ideas
T
TH ms 4
F
lab: logo
     visicalc (?)
     mu-math

week 3: start the "how" (it's done)
M   how graphics   ms 5-6   
T
TH  how lisp (computation) ms 7-*
F

lab: lisp


week 8: start the "wow"
    smalltalk: adele
    rubiks: trd
    phil: art chandler
    graphics/music: sek
    zork: bkd
    theory: vrp
    music: jc
    visicalc
    drh
    xerox people
    ai

    vlsi: ?
    nl: lewis?
    experts: ab
	Part one: Functions as passive objects
1  Notation
 	The role of notation in science
	 expressivity
	 subordination of detail
	 economy
	 amenability to proof
	The impact of computing on notation
	 executability
	 representability of algorithms
	The difficulties with programming languages

  Computation and interaction
	The relationship between language and its medium
	 why computing languages cannot be separated
	   from the programming env
	 cf. conversation and understanding
	The polarization between interaction and discipline
	 pascal vs. lisp  vs. ucsd pascal  vs smalltalk
	The polarization between rigor and hacking
	 basic vs. (lisp/scheme)


2  The language
3	Data domain: The whole numbers
	Algorithmic notation
	 conditional expressions
	 definitions
	   recursion
	 numerical examples
	computation as deduction
	   axioms for number theroy
	   rules of inference
	     substitution and simplification
		number theory
		conditional
	   the concept of proof
	    equivalence
	    termination
	Data Domain: symbolic expressions
	 the representability of programs
 	 abstract objects
	 constructors, selectors, and recognizers
	The mapping of expressions to data structures
	Non-numeric computation: examples
	  evaluation of polynomials
	  simplification of algebraic expressions
	  propositional logic: evaluation
	    ?theorem proving
	  binary trees (l-n-r) rep, sort, add, del
	  missionaries and cannibal
 	  game stuff

4  Evaluation
5	Deduction vs computation, again
	 systems for substitution and simplification
	 computation as controlled deduction
	 call-by-name vs. call-by-value
	Semantics of programming languages
	Representability of programs
	 a detailed discussion
	An evaluation algorithm
	 The operational view
	Implementation strategies
	 call-by-value
	 weak vs. strong conditional
	 simulation of substitution
	extending the evaluator
	 macros and read-macros: abbreviational convenience
	 iteration: language extension and special forms
	

6  A modern LISP: more data structuring
7	The idea of "first-class data"
	implementation-driven languages violate notational principles
	 arbitrary precision numbers
 	 Strings
	 Arrays
	 property-lists (flex records)

8  Property-lists and message passing
	classes as properties
	algorithms as message passing
	hieracharies and flavors
	  hierarchies as implementation simplification

9  Object-oriented programming
10	Smalltalk and Actors

11 Lexical vs dynamic scoping: the beginnings of active functions
	Evaluation revisited
	 functionals
	 the difficulty with functional arguments
	 variables: local, free, global
	 added complexity of functional values

12 Control: function vs algorithm
	an analysis of the evaluator
	 the run-time structure
	   stacks
	   stacks+access and control links
	   tree access, control stack
	   tree access, tree control

13 Applicative v.s. imperative
	control as a programming tool
	 side-effects
	  assignment, rplaca, rplacd

14 Implementation considerations
	implementation of the evaluation process
	 read
	  parsers and scanners
	   searching and hashing
	 print
	runtime language support
 	 i-j pairs
	 shallow versus deep
	run-time data support
	 numbers
	 arbitrary precision numbers
	 trees
	  programmer maintained
	  reference counting
	  garbage collection
	   mark sweep
	   copy-compacting
	    cheney
	    baker
	    henry&carl

15 Machines and compiling
16	The LISP machine
	Traditional machines as microcode
	Compilation
	 program representation
	  list structure
	  scheme hacks
	  p-code/byte code/MACRO
	  machine specific
	Hardware
	  LISP machine
	  Scheme chips

14 The Racks paper: a bridge  from passive to active
	Part two: Functions as active objects

1  Functions as first-class objects
  	Relationship between 
	  purity:lexical and
	  utility: dynamic
	interactive creation of functional objects
	 programming in "levels"

		
2  Applications of functional objects
     car,cdr, cons as:
	1. arrays and functional
	2. pure functional  (t, f)
	3. 1 as msg passing
3    stacks as functionals (gls/gjs)
4    multiprocessing (wand/aip)

5  Evaluation of Functionals
	evaluators for full funarg 
	evaluators for smalltalk (ingalls)

6  Applications of lisp-related computing
	cad
	nl
	business data bases  --must do much better here

7  The future of computing
	interactive programming
	language designs
	theory
	ai applications
		  EECS 129: The Art of Computer Science


This course  is  a  challenge. I  plan  to  challenge your  conception  of  what
computing is about, to challenge the traditional view of the purpose programming
languages, to challenge  the usual conception  of how one  does programming,  to
challenge the traditional curriculum of  computing, and in general to  challenge
your minds.

The  course  is  neither  mathematics  nor  engineering;  it  draws  from   both
disciplines, as does all  of computer science.  The intent of  the course is  to
investigate the phenomena called computing at  a level of abstraction that  will
allows us to explicate fundamental principles that underlie computing theory and
practice.

The texts for this course are "Zen  and the Art of Motorcycle Maintenance",  and
"Mindstorms: Computers, Children,  and Powerful Ideas".   Class notes will  form
the main structure  of the technical  and "meta-computational" perspective  that
supports the inquiry.  "Zen" has valuable insights in the relationships  between
art and science, besides the  appropriate "tone" for this course.   "Mindstorms"
is good fun:  an exemplary book showing how one can present complex ideas in  an
intuitive, yet faithful, setting.

A lab session  is associated with  this course.  Since  part of our  exploration
involves computing,  it  is  a  requirement that  one  understands  the  art  of
computing --often called "programming". Learning to program is like learning  to
drive --both  can  profit from  classroom  work that  explains  basic  concepts.
However both require "hands-on" experience before one really gets "the feel"  of
the instrument.  As with driving school, we should supply the students with  the
best available vehicles and guide them in the process of applying the theory.

There are two important practical lessons in the programming experience:   first
to develop an appreciation for abstraction and abstract programming, and  second
to develop  an understanding  of how  interactive programming  differs from  the
traditional   "batch"   (or   modified   "batch")-procesing   view.     Abstract
object-oriented  programming   carried  out   in  an   interactive   programming
environment is the future of applied computing.

The course will  be a  self-contained "mind-stretcher":   no prerequsites  other
than a  healthy  intellectual  curiousity  and  the  self-discipline  to  think.
However, the work will be demanding, so it is suggested that you have at least a
3.0 G.P.A.  in your major

WHAT I EXPECT:  A  lot! Though the course  will be self-contained, I  will
not "spoon-feed" you.  You will be expected to delve into areas other than
your major course of study:  mathematics, philosophy, education, art,  and
history are all fair game. Hopefully, there will be a sufficiently diverse
background in this class that knowledge can be pooled. If not, you (and I)
will have to dig.  If you have questions, understand where you lost track;
simply saying "I don't get it" is not satisfactory.

COURSE GRADING: Difficult! Some programming, some "fact extraction",  some
essays. Style and quality will count in all these efforts.

If you are one of those students who  feels that the only grade is an  "A"
and will drop if your GPA is threatened, then this course is not for  you.
For you "late dropper"s: be considerate  and drop early. Don't waste  your
time or hold a slot in this class that someone else might use.